home *** CD-ROM | disk | FTP | other *** search
/ NOVA - For the NeXT Workstation / NOVA - For the NeXT Workstation.iso / SourceCode / AdobeExamples / NX_Clock / ClockViewWraps.c < prev    next >
C/C++ Source or Header  |  1992-12-19  |  19KB  |  574 lines
  1. /* ClockViewWraps.c generated from ClockViewWraps.psw
  2.    by unix pswrap V1.009  Wed Apr 19 17:50:24 PDT 1989
  3.  */
  4.  
  5. #include <dpsclient/dpsfriends.h>
  6. #include <string.h>
  7.  
  8. #line 1 "ClockViewWraps.psw"
  9.  
  10. /*
  11.  * (a)  (C) 1990 by Adobe Systems Incorporated. All rights reserved.
  12.  *
  13.  * (b)  If this Sample Code is distributed as part of the Display PostScript
  14.  *    System Software Development Kit from Adobe Systems Incorporated,
  15.  *    then this copy is designated as Development Software and its use is
  16.  *    subject to the terms of the License Agreement attached to such Kit.
  17.  *
  18.  * (c)  If this Sample Code is distributed independently, then the following
  19.  *    terms apply:
  20.  *
  21.  * (d)  This file may be freely copied and redistributed as long as:
  22.  *    1) Parts (a), (d), (e) and (f) continue to be included in the file,
  23.  *    2) If the file has been modified in any way, a notice of such
  24.  *      modification is conspicuously indicated.
  25.  *
  26.  * (e)  PostScript, Display PostScript, and Adobe are registered trademarks of
  27.  *    Adobe Systems Incorporated.
  28.  * 
  29.  * (f) THE INFORMATION BELOW IS FURNISHED AS IS, IS SUBJECT TO
  30.  *    CHANGE WITHOUT NOTICE, AND SHOULD NOT BE CONSTRUED
  31.  *    AS A COMMITMENT BY ADOBE SYSTEMS INCORPORATED.
  32.  *    ADOBE SYSTEMS INCORPORATED ASSUMES NO RESPONSIBILITY
  33.  *    OR LIABILITY FOR ANY ERRORS OR INACCURACIES, MAKES NO
  34.  *    WARRANTY OF ANY KIND (EXPRESS, IMPLIED OR STATUTORY)
  35.  *    WITH RESPECT TO THIS INFORMATION, AND EXPRESSLY
  36.  *    DISCLAIMS ANY AND ALL WARRANTIES OF MERCHANTABILITY, 
  37.  *    FITNESS FOR PARTICULAR PURPOSES AND NONINFRINGEMENT
  38.  *    OF THIRD PARTY RIGHTS.
  39.  */
  40.  
  41. /*
  42. *    ClockViewWraps.psw
  43.  *
  44.  *    Version:    2.0
  45.  *    Author:    Ken Fromm
  46.  *    History:
  47.  *            03-07-91        Added this comment.
  48. */
  49.  
  50. /* StartTime is stored in the interpreter and contains the initial real time    */                                            
  51. #line 52 "ClockViewWraps.c"
  52. void PSWMarkTime( void )
  53. {
  54.   typedef struct {
  55.     unsigned char tokenType;
  56.     unsigned char topLevelCount;
  57.     unsigned short nBytes;
  58.  
  59.     DPSBinObjGeneric obj0;
  60.     DPSBinObjGeneric obj1;
  61.     DPSBinObjGeneric obj2;
  62.     } _dpsQ;
  63.   static const _dpsQ _dpsStat = {
  64.     DPS_DEF_TOKENTYPE, 3, 28,
  65.     {DPS_LITERAL|DPS_NAME, 0, 0, 0},    /* StartTime */
  66.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 328},    /* realtime */
  67.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 51},    /* def */
  68.     }; /* _dpsQ */
  69.   _dpsQ _dpsF;    /* local copy  */
  70.   register DPSContext _dpsCurCtxt = DPSPrivCurrentContext();
  71.   register DPSBinObjRec *_dpsP = (DPSBinObjRec *)&_dpsF.obj0;
  72.   static long int _dpsCodes[1] = {-1};
  73.   {
  74. if (_dpsCodes[0] < 0) {
  75.     static const char * const _dps_names[] = {
  76.     "StartTime"};
  77.     long int *_dps_nameVals[1];
  78.     _dps_nameVals[0] = &_dpsCodes[0];
  79.  
  80.     DPSMapNames(_dpsCurCtxt, 1, _dps_names, _dps_nameVals);
  81.     }
  82.   }
  83.  
  84.   _dpsF = _dpsStat;    /* assign automatic variable */
  85.  
  86.   _dpsP[0].val.nameVal = _dpsCodes[0];
  87.   DPSBinObjSeqWrite(_dpsCurCtxt,(char *) &_dpsF,28);
  88. }
  89. #line 45 "ClockViewWraps.psw"
  90.  
  91.  
  92. /* The difference between the current real time and the initial time stored                */
  93. /* in StartTime is returned to the calling procedure in the output arg ElapsedTime. */
  94. #line 95 "ClockViewWraps.c"
  95. void PSWReturnTime(int *ElapsedTime)
  96. {
  97.   typedef struct {
  98.     unsigned char tokenType;
  99.     unsigned char topLevelCount;
  100.     unsigned short nBytes;
  101.  
  102.     DPSBinObjGeneric obj0;
  103.     DPSBinObjGeneric obj1;
  104.     DPSBinObjGeneric obj2;
  105.     DPSBinObjGeneric obj3;
  106.     DPSBinObjGeneric obj4;
  107.     DPSBinObjGeneric obj5;
  108.     DPSBinObjGeneric obj6;
  109.     DPSBinObjGeneric obj7;
  110.     DPSBinObjGeneric obj8;
  111.     } _dpsQ;
  112.   static const _dpsQ _dpsStat = {
  113.     DPS_DEF_TOKENTYPE, 9, 76,
  114.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 328},    /* realtime */
  115.     {DPS_EXEC|DPS_NAME, 0, 0, 0},    /* StartTime */
  116.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 169},    /* sub */
  117.     {DPS_LITERAL|DPS_INT, 0, 0, 0},
  118.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 119},    /* printobject */
  119.     {DPS_LITERAL|DPS_INT, 0, 0, 0},
  120.     {DPS_LITERAL|DPS_INT, 0, 0, 1},
  121.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 119},    /* printobject */
  122.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 70},    /* flush */
  123.     }; /* _dpsQ */
  124.   _dpsQ _dpsF;    /* local copy  */
  125.   register DPSContext _dpsCurCtxt = DPSPrivCurrentContext();
  126.   register DPSBinObjRec *_dpsP = (DPSBinObjRec *)&_dpsF.obj0;
  127.   static long int _dpsCodes[1] = {-1};
  128.   DPSResultsRec _dpsR[1];
  129.   static const DPSResultsRec _dpsRstat[] = {
  130.     { dps_tInt, -1 },
  131.     };
  132.     _dpsR[0] = _dpsRstat[0];
  133.     _dpsR[0].value = (char *)ElapsedTime;
  134.  
  135.   {
  136. if (_dpsCodes[0] < 0) {
  137.     static const char * const _dps_names[] = {
  138.     "StartTime"};
  139.     long int *_dps_nameVals[1];
  140.     _dps_nameVals[0] = &_dpsCodes[0];
  141.  
  142.     DPSMapNames(_dpsCurCtxt, 1, _dps_names, _dps_nameVals);
  143.     }
  144.   }
  145.  
  146.   _dpsF = _dpsStat;    /* assign automatic variable */
  147.  
  148.   _dpsP[1].val.nameVal = _dpsCodes[0];
  149.   DPSSetResultTable(_dpsCurCtxt, _dpsR, 1);
  150.   DPSBinObjSeqWrite(_dpsCurCtxt,(char *) &_dpsF,76);
  151.   DPSAwaitReturnValues(_dpsCurCtxt);
  152. }
  153. #line 52 "ClockViewWraps.psw"
  154.  
  155. #line 156 "ClockViewWraps.c"
  156. void PSWEraseView(float BGColor, float X, float Y, float W, float H)
  157. {
  158.   typedef struct {
  159.     unsigned char tokenType;
  160.     unsigned char topLevelCount;
  161.     unsigned short nBytes;
  162.  
  163.     DPSBinObjReal obj0;
  164.     DPSBinObjGeneric obj1;
  165.     DPSBinObjReal obj2;
  166.     DPSBinObjReal obj3;
  167.     DPSBinObjReal obj4;
  168.     DPSBinObjReal obj5;
  169.     DPSBinObjGeneric obj6;
  170.     } _dpsQ;
  171.   static const _dpsQ _dpsStat = {
  172.     DPS_DEF_TOKENTYPE, 7, 60,
  173.     {DPS_LITERAL|DPS_REAL, 0, 0, 0},    /* param: BGColor */
  174.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 150},    /* setgray */
  175.     {DPS_LITERAL|DPS_REAL, 0, 0, 0},    /* param: X */
  176.     {DPS_LITERAL|DPS_REAL, 0, 0, 0},    /* param: Y */
  177.     {DPS_LITERAL|DPS_REAL, 0, 0, 0},    /* param: W */
  178.     {DPS_LITERAL|DPS_REAL, 0, 0, 0},    /* param: H */
  179.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 128},    /* rectfill */
  180.     }; /* _dpsQ */
  181.   _dpsQ _dpsF;    /* local copy  */
  182.   register DPSContext _dpsCurCtxt = DPSPrivCurrentContext();
  183.   register DPSBinObjRec *_dpsP = (DPSBinObjRec *)&_dpsF.obj0;
  184.   _dpsF = _dpsStat;    /* assign automatic variable */
  185.  
  186.   _dpsP[0].val.realVal = BGColor;
  187.   _dpsP[2].val.realVal = X;
  188.   _dpsP[3].val.realVal = Y;
  189.   _dpsP[4].val.realVal = W;
  190.   _dpsP[5].val.realVal = H;
  191.   DPSBinObjSeqWrite(_dpsCurCtxt,(char *) &_dpsF,60);
  192. }
  193. #line 56 "ClockViewWraps.psw"
  194.  
  195. #line 196 "ClockViewWraps.c"
  196. void PSWMakeCircle(float X, float Y, float Rad)
  197. {
  198.   typedef struct {
  199.     unsigned char tokenType;
  200.     unsigned char topLevelCount;
  201.     unsigned short nBytes;
  202.  
  203.     DPSBinObjReal obj0;
  204.     DPSBinObjReal obj1;
  205.     DPSBinObjGeneric obj2;
  206.     DPSBinObjReal obj3;
  207.     DPSBinObjGeneric obj4;
  208.     DPSBinObjReal obj5;
  209.     DPSBinObjReal obj6;
  210.     DPSBinObjReal obj7;
  211.     DPSBinObjGeneric obj8;
  212.     DPSBinObjGeneric obj9;
  213.     DPSBinObjGeneric obj10;
  214.     } _dpsQ;
  215.   static const _dpsQ _dpsStat = {
  216.     DPS_DEF_TOKENTYPE, 11, 92,
  217.     {DPS_LITERAL|DPS_REAL, 0, 0, 0},    /* param: X */
  218.     {DPS_LITERAL|DPS_REAL, 0, 0, 0},    /* param: Rad */
  219.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 1},    /* add */
  220.     {DPS_LITERAL|DPS_REAL, 0, 0, 0},    /* param: Y */
  221.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 107},    /* moveto */
  222.     {DPS_LITERAL|DPS_REAL, 0, 0, 0},    /* param: X */
  223.     {DPS_LITERAL|DPS_REAL, 0, 0, 0},    /* param: Y */
  224.     {DPS_LITERAL|DPS_REAL, 0, 0, 0},    /* param: Rad */
  225.     {DPS_LITERAL|DPS_INT, 0, 0, 0},
  226.     {DPS_LITERAL|DPS_INT, 0, 0, 360},
  227.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 5},    /* arc */
  228.     }; /* _dpsQ */
  229.   _dpsQ _dpsF;    /* local copy  */
  230.   register DPSContext _dpsCurCtxt = DPSPrivCurrentContext();
  231.   register DPSBinObjRec *_dpsP = (DPSBinObjRec *)&_dpsF.obj0;
  232.   _dpsF = _dpsStat;    /* assign automatic variable */
  233.  
  234.   _dpsP[0].val.realVal =
  235.   _dpsP[5].val.realVal = X;
  236.   _dpsP[3].val.realVal =
  237.   _dpsP[6].val.realVal = Y;
  238.   _dpsP[1].val.realVal =
  239.   _dpsP[7].val.realVal = Rad;
  240.   DPSBinObjSeqWrite(_dpsCurCtxt,(char *) &_dpsF,92);
  241. }
  242. #line 60 "ClockViewWraps.psw"
  243.  
  244. #line 245 "ClockViewWraps.c"
  245. void PSWFillPath(float Color)
  246. {
  247.   typedef struct {
  248.     unsigned char tokenType;
  249.     unsigned char topLevelCount;
  250.     unsigned short nBytes;
  251.  
  252.     DPSBinObjReal obj0;
  253.     DPSBinObjGeneric obj1;
  254.     DPSBinObjGeneric obj2;
  255.     } _dpsQ;
  256.   static const _dpsQ _dpsStat = {
  257.     DPS_DEF_TOKENTYPE, 3, 28,
  258.     {DPS_LITERAL|DPS_REAL, 0, 0, 0},    /* param: Color */
  259.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 150},    /* setgray */
  260.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 66},    /* fill */
  261.     }; /* _dpsQ */
  262.   _dpsQ _dpsF;    /* local copy  */
  263.   register DPSContext _dpsCurCtxt = DPSPrivCurrentContext();
  264.   register DPSBinObjRec *_dpsP = (DPSBinObjRec *)&_dpsF.obj0;
  265.   _dpsF = _dpsStat;    /* assign automatic variable */
  266.  
  267.   _dpsP[0].val.realVal = Color;
  268.   DPSBinObjSeqWrite(_dpsCurCtxt,(char *) &_dpsF,28);
  269. }
  270. #line 64 "ClockViewWraps.psw"
  271.  
  272. #line 273 "ClockViewWraps.c"
  273. void PSWSetUpath(float Pts[], int Tot_Pts, char Ops[], int Tot_Ops)
  274. {
  275.   typedef struct {
  276.     unsigned char tokenType;
  277.     unsigned char topLevelCount;
  278.     unsigned short nBytes;
  279.  
  280.     DPSBinObjGeneric obj0;
  281.     DPSBinObjGeneric obj1;
  282.     DPSBinObjGeneric obj2;
  283.     } _dpsQ;
  284.   static const _dpsQ _dpsStat = {
  285.     DPS_DEF_TOKENTYPE, 1, 28,
  286.     {DPS_LITERAL|DPS_ARRAY, 0, 2, 8},
  287.     {DPS_LITERAL|DPS_ARRAY, 0, 0, 24},    /* param[var]: Pts */
  288.     {DPS_LITERAL|DPS_STRING, 0, 0, 24},    /* param Ops */
  289.     }; /* _dpsQ */
  290.   _dpsQ _dpsF;    /* local copy  */
  291.   register DPSContext _dpsCurCtxt = DPSPrivCurrentContext();
  292.   register DPSBinObjRec *_dpsP = (DPSBinObjRec *)&_dpsF.obj0;
  293.   register int _dps_offset = 24;
  294.   _dpsF = _dpsStat;    /* assign automatic variable */
  295.  
  296.   _dpsP[1].length = Tot_Pts;
  297.   _dpsP[2].length = Tot_Ops;
  298.   _dpsP[1].val.arrayVal = _dps_offset;
  299.   _dps_offset += Tot_Pts * sizeof(DPSBinObjGeneric);
  300.   _dpsP[2].val.stringVal = _dps_offset;
  301.   _dps_offset += (Tot_Ops + 3) & ~3;
  302.  
  303.   _dpsF.nBytes = _dps_offset+4;
  304.   DPSBinObjSeqWrite(_dpsCurCtxt,(char *) &_dpsF,28);
  305.   DPSWriteTypedObjectArray(_dpsCurCtxt, dps_tFloat, (char *)Pts, Tot_Pts);
  306.   DPSWriteStringChars(_dpsCurCtxt, (char *)Ops, Tot_Ops);
  307.   DPSWriteStringChars(_dpsCurCtxt, (char *)_dpsCurCtxt, ~(Tot_Ops + 3) & 3);
  308. }
  309. #line 69 "ClockViewWraps.psw"
  310.  
  311. #line 312 "ClockViewWraps.c"
  312. void PSWSetGstate(float X, float Y, float Gray, float Linewidth)
  313. {
  314.   typedef struct {
  315.     unsigned char tokenType;
  316.     unsigned char topLevelCount;
  317.     unsigned short nBytes;
  318.  
  319.     DPSBinObjGeneric obj0;
  320.     DPSBinObjReal obj1;
  321.     DPSBinObjReal obj2;
  322.     DPSBinObjGeneric obj3;
  323.     DPSBinObjReal obj4;
  324.     DPSBinObjGeneric obj5;
  325.     DPSBinObjReal obj6;
  326.     DPSBinObjGeneric obj7;
  327.     } _dpsQ;
  328.   static const _dpsQ _dpsStat = {
  329.     DPS_DEF_TOKENTYPE, 8, 68,
  330.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 111},    /* newpath */
  331.     {DPS_LITERAL|DPS_REAL, 0, 0, 0},    /* param: X */
  332.     {DPS_LITERAL|DPS_REAL, 0, 0, 0},    /* param: Y */
  333.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 173},    /* translate */
  334.     {DPS_LITERAL|DPS_REAL, 0, 0, 0},    /* param: Gray */
  335.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 150},    /* setgray */
  336.     {DPS_LITERAL|DPS_REAL, 0, 0, 0},    /* param: Linewidth */
  337.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 155},    /* setlinewidth */
  338.     }; /* _dpsQ */
  339.   _dpsQ _dpsF;    /* local copy  */
  340.   register DPSContext _dpsCurCtxt = DPSPrivCurrentContext();
  341.   register DPSBinObjRec *_dpsP = (DPSBinObjRec *)&_dpsF.obj0;
  342.   _dpsF = _dpsStat;    /* assign automatic variable */
  343.  
  344.   _dpsP[1].val.realVal = X;
  345.   _dpsP[2].val.realVal = Y;
  346.   _dpsP[4].val.realVal = Gray;
  347.   _dpsP[6].val.realVal = Linewidth;
  348.   DPSBinObjSeqWrite(_dpsCurCtxt,(char *) &_dpsF,68);
  349. }
  350. #line 73 "ClockViewWraps.psw"
  351.  
  352. #line 353 "ClockViewWraps.c"
  353. void PSWInstallGstate(int GState, float Angle)
  354. {
  355.   typedef struct {
  356.     unsigned char tokenType;
  357.     unsigned char topLevelCount;
  358.     unsigned short nBytes;
  359.  
  360.     DPSBinObjGeneric obj0;
  361.     DPSBinObjGeneric obj1;
  362.     DPSBinObjGeneric obj2;
  363.     DPSBinObjReal obj3;
  364.     DPSBinObjGeneric obj4;
  365.     } _dpsQ;
  366.   static const _dpsQ _dpsStat = {
  367.     DPS_DEF_TOKENTYPE, 5, 44,
  368.     {DPS_LITERAL|DPS_INT, 0, 0, 0},    /* param: GState */
  369.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 212},    /* execuserobject */
  370.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 151},    /* setgstate */
  371.     {DPS_LITERAL|DPS_REAL, 0, 0, 0},    /* param: Angle */
  372.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 136},    /* rotate */
  373.     }; /* _dpsQ */
  374.   _dpsQ _dpsF;    /* local copy  */
  375.   register DPSContext _dpsCurCtxt = DPSPrivCurrentContext();
  376.   register DPSBinObjRec *_dpsP = (DPSBinObjRec *)&_dpsF.obj0;
  377.   _dpsF = _dpsStat;    /* assign automatic variable */
  378.  
  379.   _dpsP[0].val.integerVal = GState;
  380.   _dpsP[3].val.realVal = Angle;
  381.   DPSBinObjSeqWrite(_dpsCurCtxt,(char *) &_dpsF,44);
  382. }
  383. #line 78 "ClockViewWraps.psw"
  384.  
  385. #line 386 "ClockViewWraps.c"
  386. void PSWUpathStrokeFill(int UPath)
  387. {
  388.   typedef struct {
  389.     unsigned char tokenType;
  390.     unsigned char topLevelCount;
  391.     unsigned short nBytes;
  392.  
  393.     DPSBinObjGeneric obj0;
  394.     DPSBinObjGeneric obj1;
  395.     DPSBinObjGeneric obj2;
  396.     DPSBinObjGeneric obj3;
  397.     DPSBinObjGeneric obj4;
  398.     DPSBinObjReal obj5;
  399.     DPSBinObjGeneric obj6;
  400.     DPSBinObjGeneric obj7;
  401.     DPSBinObjGeneric obj8;
  402.     } _dpsQ;
  403.   static const _dpsQ _dpsStat = {
  404.     DPS_DEF_TOKENTYPE, 9, 76,
  405.     {DPS_LITERAL|DPS_INT, 0, 0, 0},    /* param: UPath */
  406.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 212},    /* execuserobject */
  407.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 56},    /* dup */
  408.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 183},    /* ustroke */
  409.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 33},    /* currentgray */
  410.     {DPS_LITERAL|DPS_REAL, 0, 0, 0.2},
  411.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 1},    /* add */
  412.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 150},    /* setgray */
  413.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 179},    /* ufill */
  414.     }; /* _dpsQ */
  415.   _dpsQ _dpsF;    /* local copy  */
  416.   register DPSContext _dpsCurCtxt = DPSPrivCurrentContext();
  417.   register DPSBinObjRec *_dpsP = (DPSBinObjRec *)&_dpsF.obj0;
  418.   _dpsF = _dpsStat;    /* assign automatic variable */
  419.  
  420.   _dpsP[0].val.integerVal = UPath;
  421.   DPSBinObjSeqWrite(_dpsCurCtxt,(char *) &_dpsF,76);
  422. }
  423. #line 84 "ClockViewWraps.psw"
  424.  
  425. #line 426 "ClockViewWraps.c"
  426. void PSWUpathFill(int UPath)
  427. {
  428.   typedef struct {
  429.     unsigned char tokenType;
  430.     unsigned char topLevelCount;
  431.     unsigned short nBytes;
  432.  
  433.     DPSBinObjGeneric obj0;
  434.     DPSBinObjGeneric obj1;
  435.     DPSBinObjGeneric obj2;
  436.     } _dpsQ;
  437.   static const _dpsQ _dpsStat = {
  438.     DPS_DEF_TOKENTYPE, 3, 28,
  439.     {DPS_LITERAL|DPS_INT, 0, 0, 0},    /* param: UPath */
  440.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 212},    /* execuserobject */
  441.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 179},    /* ufill */
  442.     }; /* _dpsQ */
  443.   _dpsQ _dpsF;    /* local copy  */
  444.   register DPSContext _dpsCurCtxt = DPSPrivCurrentContext();
  445.   register DPSBinObjRec *_dpsP = (DPSBinObjRec *)&_dpsF.obj0;
  446.   _dpsF = _dpsStat;    /* assign automatic variable */
  447.  
  448.   _dpsP[0].val.integerVal = UPath;
  449.   DPSBinObjSeqWrite(_dpsCurCtxt,(char *) &_dpsF,28);
  450. }
  451. #line 88 "ClockViewWraps.psw"
  452.  
  453. #line 454 "ClockViewWraps.c"
  454. void PSWDrawCircle(float Color)
  455. {
  456.   typedef struct {
  457.     unsigned char tokenType;
  458.     unsigned char topLevelCount;
  459.     unsigned short nBytes;
  460.  
  461.     DPSBinObjReal obj0;
  462.     DPSBinObjGeneric obj1;
  463.     DPSBinObjGeneric obj2;
  464.     DPSBinObjGeneric obj3;
  465.     DPSBinObjGeneric obj4;
  466.     DPSBinObjGeneric obj5;
  467.     DPSBinObjGeneric obj6;
  468.     DPSBinObjGeneric obj7;
  469.     DPSBinObjGeneric obj8;
  470.     DPSBinObjGeneric obj9;
  471.     } _dpsQ;
  472.   static const _dpsQ _dpsStat = {
  473.     DPS_DEF_TOKENTYPE, 10, 84,
  474.     {DPS_LITERAL|DPS_REAL, 0, 0, 0},    /* param: Color */
  475.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 150},    /* setgray */
  476.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 111},    /* newpath */
  477.     {DPS_LITERAL|DPS_INT, 0, 0, 0},
  478.     {DPS_LITERAL|DPS_INT, 0, 0, 0},
  479.     {DPS_LITERAL|DPS_INT, 0, 0, 10},
  480.     {DPS_LITERAL|DPS_INT, 0, 0, 0},
  481.     {DPS_LITERAL|DPS_INT, 0, 0, 360},
  482.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 5},    /* arc */
  483.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 167},    /* stroke */
  484.     }; /* _dpsQ */
  485.   _dpsQ _dpsF;    /* local copy  */
  486.   register DPSContext _dpsCurCtxt = DPSPrivCurrentContext();
  487.   register DPSBinObjRec *_dpsP = (DPSBinObjRec *)&_dpsF.obj0;
  488.   _dpsF = _dpsStat;    /* assign automatic variable */
  489.  
  490.   _dpsP[0].val.realVal = Color;
  491.   DPSBinObjSeqWrite(_dpsCurCtxt,(char *) &_dpsF,84);
  492. }
  493. #line 93 "ClockViewWraps.psw"
  494.  
  495. #line 496 "ClockViewWraps.c"
  496. void PSWHitPath(int UPath1, int UPath2, float HPts[], int Tot_HPts, char HOps[], int Tot_HOps, int *Hit)
  497. {
  498.   typedef struct {
  499.     unsigned char tokenType;
  500.     unsigned char topLevelCount;
  501.     unsigned short nBytes;
  502.  
  503.     DPSBinObjGeneric obj0;
  504.     DPSBinObjGeneric obj1;
  505.     DPSBinObjGeneric obj2;
  506.     DPSBinObjGeneric obj3;
  507.     DPSBinObjGeneric obj4;
  508.     DPSBinObjGeneric obj5;
  509.     DPSBinObjGeneric obj6;
  510.     DPSBinObjGeneric obj7;
  511.     DPSBinObjGeneric obj8;
  512.     DPSBinObjGeneric obj9;
  513.     DPSBinObjGeneric obj10;
  514.     DPSBinObjGeneric obj11;
  515.     DPSBinObjGeneric obj12;
  516.     DPSBinObjGeneric obj13;
  517.     DPSBinObjGeneric obj14;
  518.     DPSBinObjGeneric obj15;
  519.     DPSBinObjGeneric obj16;
  520.     } _dpsQ;
  521.   static const _dpsQ _dpsStat = {
  522.     DPS_DEF_TOKENTYPE, 15, 140,
  523.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 111},    /* newpath */
  524.     {DPS_LITERAL|DPS_INT, 0, 0, 0},    /* param: UPath1 */
  525.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 212},    /* execuserobject */
  526.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 176},    /* uappend */
  527.     {DPS_LITERAL|DPS_INT, 0, 0, 0},    /* param: UPath2 */
  528.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 212},    /* execuserobject */
  529.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 176},    /* uappend */
  530.     {DPS_LITERAL|DPS_ARRAY, 0, 2, 120},
  531.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 90},    /* infill */
  532.     {DPS_LITERAL|DPS_INT, 0, 0, 0},
  533.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 119},    /* printobject */
  534.     {DPS_LITERAL|DPS_INT, 0, 0, 0},
  535.     {DPS_LITERAL|DPS_INT, 0, 0, 1},
  536.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 119},    /* printobject */
  537.     {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 70},    /* flush */
  538.     {DPS_LITERAL|DPS_ARRAY, 0, 0, 136},    /* param[var]: HPts */
  539.     {DPS_LITERAL|DPS_STRING, 0, 0, 136},    /* param HOps */
  540.     }; /* _dpsQ */
  541.   _dpsQ _dpsF;    /* local copy  */
  542.   register DPSContext _dpsCurCtxt = DPSPrivCurrentContext();
  543.   register DPSBinObjRec *_dpsP = (DPSBinObjRec *)&_dpsF.obj0;
  544.   register int _dps_offset = 136;
  545.   DPSResultsRec _dpsR[1];
  546.   static const DPSResultsRec _dpsRstat[] = {
  547.     { dps_tBoolean, -1 },
  548.     };
  549.     _dpsR[0] = _dpsRstat[0];
  550.     _dpsR[0].value = (char *)Hit;
  551.  
  552.   _dpsF = _dpsStat;    /* assign automatic variable */
  553.  
  554.   _dpsP[1].val.integerVal = UPath1;
  555.   _dpsP[4].val.integerVal = UPath2;
  556.   _dpsP[15].length = Tot_HPts;
  557.   _dpsP[16].length = Tot_HOps;
  558.   _dpsP[15].val.arrayVal = _dps_offset;
  559.   _dps_offset += Tot_HPts * sizeof(DPSBinObjGeneric);
  560.   _dpsP[16].val.stringVal = _dps_offset;
  561.   _dps_offset += (Tot_HOps + 3) & ~3;
  562.  
  563.   _dpsF.nBytes = _dps_offset+4;
  564.   DPSSetResultTable(_dpsCurCtxt, _dpsR, 1);
  565.   DPSBinObjSeqWrite(_dpsCurCtxt,(char *) &_dpsF,140);
  566.   DPSWriteTypedObjectArray(_dpsCurCtxt, dps_tFloat, (char *)HPts, Tot_HPts);
  567.   DPSWriteStringChars(_dpsCurCtxt, (char *)HOps, Tot_HOps);
  568.   DPSWriteStringChars(_dpsCurCtxt, (char *)_dpsCurCtxt, ~(Tot_HOps + 3) & 3);
  569.   DPSAwaitReturnValues(_dpsCurCtxt);
  570. }
  571. #line 98 "ClockViewWraps.psw"
  572.  
  573.  
  574.